home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 2 / The 640 Meg Shareware Studio CD-ROM Volume II (Data Express)(1993).ISO / clang / but_dsgn.zip / BUT_DSGN.C < prev    next >
C/C++ Source or Header  |  1991-03-17  |  15KB  |  639 lines
  1. #include    <vdi.h>
  2. #include    <aes.h>
  3. #include    <stdio.h>
  4. #include    <tos.h>
  5. #include    <string.h>
  6. #include    "but_dsgn.h"
  7. #include    "but_dsgn.rsh"
  8.  
  9.  
  10. /* Prototypen */
  11.  
  12. void hauptprogramm(void);
  13. void handle_form(int sel_obj);
  14. void redraw(int tree_nr, int obnr);
  15. void edit_on_switch(void);
  16. void edit_off_switch(void);
  17. void save_bitmap(void);
  18. void load_bitmap(void);
  19. void save_c_code(char *mode);
  20. void make_header(FILE *dest);
  21. void make_raster(void);
  22. void clear_raster(void);
  23. void copy_to_raster(void);
  24. void move_up(void);
  25. void move_down(void);
  26. void move_left(void);
  27. void move_right(void);
  28. void switch_test(void);
  29. void flip_pixel(int mx, int my);
  30. void copy_bitmap(char *src, int obj);
  31. void main_init(void);
  32.  
  33.  
  34. /* einige Macros */
  35.  
  36. #define        Pfeil    graf_mouse(ARROW, 0)
  37. #define        Biene    graf_mouse(BUSYBEE, 0)
  38. #define        TRUE    1
  39. #define        FALSE    0
  40.  
  41. #define        PIXELBREITE        7    /* im Malraster */
  42. #define        RASTERBREITE    16
  43. #define        RASTERHOEHE        16
  44. #define        RASTER_WORTE    16
  45.  
  46.  
  47. /* ----------------------------------- */
  48.  
  49. int        appl_id, msgbuf[8], vdi_handle,        /* GEM-Krams */
  50.         work_in[] = {1,1,1,1,1,1,1,1,1,1,2},
  51.         work_out[57], dummy, mouse_x, mouse_y;
  52.  
  53. char    path[128],                /* Puffer fuer Pfadnamen */
  54.         f_name[14] = "",
  55.         *schaltername;
  56.  
  57. unsigned int    *on_bitmap, *off_bitmap,
  58.                 *switch_bitmap;            /* die akt. Switch-Bitmap */
  59.  
  60. int        cur_switch,                /* das aktuelle Switch-Objekt */
  61.         test_status,
  62.         color_index[] = {1,0};
  63.  
  64. enum    {TOGGLE,ON,OFF} drawing_mode;
  65.  
  66. MFDB    screen_mfdb, bitmap_mfdb;
  67.  
  68.  
  69. /* Alert - Texte */
  70.  
  71. char    noname_alert[] =    "[1][ |"
  72.                             " Es wurde noch kein Name für|"
  73.                             " diesen Schalter eingegeben!]"
  74.                             "[ Ok ]";
  75.  
  76.  
  77. /* ================================================================ */
  78.  
  79. int main(void)
  80. {
  81.     int pxy[4];
  82.     
  83.     appl_id = appl_init();
  84.     
  85.     if (appl_id != -1)
  86.     {
  87.         vdi_handle = graf_handle(&dummy, &dummy, &dummy, &dummy);
  88.         v_opnvwk(work_in, &vdi_handle, work_out);
  89.         if (vdi_handle != 0)
  90.         {
  91.             /* Default-Clipping setzen */
  92.             
  93.             pxy[0] = pxy[1] = 0;
  94.             pxy[2] = work_out[0];
  95.             pxy[3] = work_out[1];
  96.             vs_clip(vdi_handle, 1, pxy);
  97.             
  98.             main_init();
  99.             
  100.             Pfeil;
  101.             
  102.             hauptprogramm();
  103.             
  104.             v_clsvwk(vdi_handle);
  105.         }
  106.         appl_exit();
  107.     }
  108.     return(0);
  109. }
  110.  
  111.  
  112. /* ================================================================ */
  113.  
  114. void hauptprogramm(void)
  115. {
  116.     int        x, y, w, h, sel_obj, m_button;
  117.     
  118.     form_center(TREE[MAINFORM], &x, &y, &w, &h);
  119.     form_dial(FMD_START, 0, 0, 0, 0, x, y, w, h);
  120.     form_dial(FMD_GROW, x+w/2, y+h/2, 10, 10, x, y, w, h);
  121.     redraw(MAINFORM, 0);
  122.     make_raster();
  123.     
  124.     do
  125.     {
  126.         graf_mkstate(&dummy, &dummy, &m_button, &dummy);
  127.         if (!m_button) drawing_mode = TOGGLE;
  128.         
  129.         sel_obj = form_do(TREE[MAINFORM], (drawing_mode == TOGGLE)
  130.                                             ? SWTCHNME : -1);
  131.         graf_mkstate(&mouse_x, &mouse_y, &dummy, &dummy);
  132.         sel_obj &= 0x7fff;        /* Doppelklicks ignorieren */
  133.         handle_form(sel_obj);
  134.  
  135.     } while(sel_obj != ENDE);
  136.     
  137.     form_dial(FMD_SHRINK, x+w/2, y+h/2, 10, 10, x, y, w, h);
  138.     form_dial(FMD_FINISH, 0, 0, 0, 0, x, y, w, h);
  139. }
  140.  
  141.  
  142. /* ================================================================ */
  143.  
  144. void handle_form(int sel_obj)
  145. {
  146.     /*    Verzweigt aufgrund des selektierten Objektes    */
  147.     /*    in die entsprechenden Routinen.                    */
  148.     
  149.     switch (sel_obj)
  150.     {
  151.         case    RASTER        :    flip_pixel(mouse_x, mouse_y);
  152.                                 break;
  153.         case    BUTNEIN        :
  154.         case    BUTNAUS        :    if (sel_obj == BUTNAUS)
  155.                                     edit_off_switch();
  156.                                 else
  157.                                     edit_on_switch();
  158.                                 make_raster();
  159.                                 redraw(MAINFORM, EINTEXT);
  160.                                 redraw(MAINFORM, AUSTEXT);
  161.                                 redraw(MAINFORM, ORSWITCH);
  162.                                 break;
  163.         case    CLEARALL    :    clear_raster(); break;
  164.         case    ORSWITCH    :    copy_to_raster(); break;
  165.         case    MOVEUP        :    move_up(); break;
  166.         case    MOVEDOWN    :    move_down(); break;
  167.         case    MOVELEFT    :    move_left(); break;
  168.         case    MOVERGHT    :    move_right(); break;
  169.         case    TEST        :    switch_test(); break;
  170.         case    NEWCODE        :    save_c_code("w"); break;
  171.         case    APPEND        :    save_c_code("a"); break;
  172.         case    SAVEIMG        :    save_bitmap(); break;
  173.         case    LOADIMG        :    load_bitmap(); break;
  174.     }
  175.     
  176.     switch (sel_obj)
  177.     {
  178.         /* Raster-Update nach diesen Aufrufen */
  179.         
  180.         case CLEARALL :        case ORSWITCH :        case MOVEUP    :
  181.         case MOVEDOWN :        case MOVELEFT :        case MOVERGHT :
  182.         
  183.             make_raster();
  184.             copy_bitmap((char *) switch_bitmap, cur_switch);
  185.             break;
  186.         
  187.         /* Komplett-Redraw nach diesen Aufrufen */
  188.         
  189.         case NEWCODE :        case APPEND :        case SAVEIMG :
  190.         case LOADIMG :
  191.         
  192.             redraw(MAINFORM, 0); make_raster();
  193.             break;
  194.     }
  195. }
  196.  
  197.  
  198. /* ================================================================ */
  199.  
  200. void main_init(void)
  201. {
  202.     objc_init();    /* nötig, da wir die Resource nicht mir    */
  203.                     /* 'rsrc_load' laden                    */
  204.     
  205.     /* Formular und Variablen vorbelegen */
  206.     
  207.     path[0] = Dgetdrv() + 'A';
  208.     path[1] = ':';
  209.     Dgetpath(&path[2], 0);
  210.     strcat(path, "\\");
  211.     
  212.     /*  Diese Zeiger sparen Schreibarbeit */
  213.     
  214.     on_bitmap =     (unsigned int *)
  215.                     TREE[MAINFORM][BUTNEIN].ob_spec.bitblk->bi_pdata;
  216.     off_bitmap =    (unsigned int *)
  217.                     TREE[MAINFORM][BUTNAUS].ob_spec.bitblk->bi_pdata;
  218.     schaltername =    TREE[MAINFORM][SWTCHNME].ob_spec.tedinfo->te_ptext;
  219.     
  220.     schaltername[0] = 0;    /* Eingabefeld löschen        */
  221.     edit_off_switch();        /* Starteditierung ist der    */
  222.                             /* deselektierte Schalter    */
  223.     
  224.     drawing_mode = TOGGLE;
  225.     
  226.     screen_mfdb.fd_addr = NULL;        /* = Bildschirm */
  227.     
  228.     /* Quelle für Rasterkopien */
  229.     
  230.     bitmap_mfdb.fd_w        =    RASTERBREITE;
  231.     bitmap_mfdb.fd_h        =    RASTERHOEHE;
  232.     bitmap_mfdb.fd_wdwidth    =    1;
  233.     bitmap_mfdb.fd_stand    =    1;
  234.     bitmap_mfdb.fd_nplanes    =    1;
  235. }
  236.  
  237.  
  238. /* ================================================================ */
  239.  
  240. void redraw(int tree_nr, int obnr)
  241. {
  242.     /* Zeichnet Objekt 'obnr' in Baum 'tree_nr' neu */
  243.     
  244.     objc_draw(TREE[tree_nr], obnr, MAX_DEPTH, 0, 0, 0, 0);
  245.                                             /* = Default-Clipping */
  246. }
  247.  
  248.  
  249. /* ================================================================ */
  250.  
  251. void clear_raster(void)
  252. {
  253.     int    i;
  254.     
  255.     for (i=0; i < RASTER_WORTE; switch_bitmap[i++] = 0);
  256. }
  257.  
  258. /* ================================================================ */
  259.  
  260. void copy_to_raster(void)
  261. {
  262.     unsigned int    i, *source;
  263.     
  264.     if (switch_bitmap == on_bitmap)
  265.         source = off_bitmap;
  266.     else
  267.         source = on_bitmap;
  268.     
  269.     for (i=0; i < RASTER_WORTE; switch_bitmap[i] |= source[i++]);
  270. }
  271.  
  272.  
  273. /* ================================================================ */
  274.  
  275. void move_up(void)
  276. {
  277.     int i;
  278.     
  279.     for (i=0; i < RASTER_WORTE - 1; i++)
  280.         switch_bitmap[i] = switch_bitmap[i+1];
  281.     switch_bitmap[RASTER_WORTE - 1] = 0;
  282. }
  283.  
  284.  
  285. /* ================================================================ */
  286.  
  287. void move_down(void)
  288. {
  289.     int i;
  290.     
  291.     for (i = RASTER_WORTE - 1; i > 0; i--)
  292.         switch_bitmap[i] = switch_bitmap[i-1];
  293.     switch_bitmap[0] = 0;
  294. }
  295.  
  296.  
  297. /* ================================================================ */
  298.  
  299. void move_left(void)
  300. {
  301.     int i;
  302.     
  303.     for (i=0; i < RASTER_WORTE; switch_bitmap[i++] <<= 1);
  304. }
  305.  
  306.  
  307. /* ================================================================ */
  308.  
  309. void move_right(void)
  310. {
  311.     int i;
  312.     
  313.     for (i=0; i < RASTER_WORTE; switch_bitmap[i++] >>= 1);
  314. }
  315.  
  316.  
  317. /* ================================================================ */
  318.  
  319. void switch_test(void)
  320. {
  321.     /* Kopiert wechselweise den selektierten oder    */
  322.     /* deselektierten Schalter ins Testfeld            */
  323.     
  324.     int    dum, mb;
  325.     
  326.     if (test_status)
  327.     {
  328.         test_status = 0;
  329.         copy_bitmap((char *) on_bitmap, TESTAREA);
  330.     }
  331.     else
  332.     {
  333.         test_status = 1;
  334.         copy_bitmap((char *) off_bitmap, TESTAREA);
  335.     }
  336.     
  337.     do
  338.     {
  339.         /* und auf Loslassen der Maustaste warten */
  340.         graf_mkstate(&dum, &dum, &mb, &dum);
  341.     } while(mb);
  342. }
  343.  
  344.  
  345. /* ================================================================ */
  346.  
  347. void edit_on_switch(void)
  348. {
  349.     /* Schaltet auf Editierung des selektierten    */
  350.     /* Schalters um (ohne 'redraw')                */
  351.     
  352.     cur_switch = BUTNEIN;
  353.     switch_bitmap = on_bitmap;
  354.     
  355.     TREE[MAINFORM][AUSTEXT].ob_state = DISABLED;
  356.     TREE[MAINFORM][EINTEXT].ob_state = NONE;
  357.     TREE[MAINFORM][ORSWITCH].ob_spec.free_string = "RASTER +'AUS'";
  358. }
  359.  
  360.  
  361. /* ================================================================ */
  362.  
  363. void edit_off_switch(void)
  364. {
  365.     /* Schaltet auf Editierung des deselektierten    */
  366.     /* Schalters um (ohne 'redraw')                    */
  367.     
  368.     cur_switch = BUTNAUS;
  369.     switch_bitmap = off_bitmap;
  370.     
  371.     TREE[MAINFORM][EINTEXT].ob_state = DISABLED;
  372.     TREE[MAINFORM][AUSTEXT].ob_state = NONE;
  373.     TREE[MAINFORM][ORSWITCH].ob_spec.free_string = "RASTER +'EIN'";
  374. }
  375.  
  376.  
  377. /* ================================================================ */
  378.  
  379. void make_raster(void)
  380. {
  381.     /* Zeichnet in den Button 'RASTER' ein Gitter    */
  382.     /* und füllt alle Punkte, die in der aktuellen    */
  383.     /* 'switch_bitmap' gesetzt sind                    */
  384.     
  385.     int        pxy[4], x_min, y_min, x_max, y_max, mask, x, y;
  386.     
  387.     objc_offset(TREE[MAINFORM], RASTER, &x_min, &y_min);
  388.     
  389.     x_max = x_min+TREE[MAINFORM][RASTER].ob_width;
  390.     y_max = y_min+TREE[MAINFORM][RASTER].ob_height;
  391.     
  392.     vsl_udsty(vdi_handle, 0xAAAA);    /* Punktiert */
  393.     vsl_type(vdi_handle, 7);
  394.     v_hide_c(vdi_handle);
  395.     
  396.     pxy[0] = x_min + PIXELBREITE; pxy[1] = y_min;
  397.     pxy[2] = pxy[0]; pxy[3] = y_max - 1;
  398.     
  399.     while (pxy[0] < x_max)
  400.     {
  401.         v_pline(vdi_handle, 2, pxy);
  402.         pxy[0] += PIXELBREITE + 1;
  403.         pxy[2] += PIXELBREITE + 1;
  404.     }
  405.     
  406.     pxy[0] = x_min; pxy[1] = y_min + PIXELBREITE;
  407.     pxy[2] = x_max - 1; pxy[3] = pxy[1];
  408.     
  409.     while (pxy[1] < y_max)
  410.     {
  411.         v_pline(vdi_handle, 2, pxy);
  412.         pxy[1] += PIXELBREITE + 1;
  413.         pxy[3] += PIXELBREITE + 1;
  414.     }
  415.     
  416.     for (x = 0; x < RASTERBREITE; x++)
  417.         for (y = 0; y < RASTERHOEHE; y++)
  418.         {
  419.             pxy[0] = x_min + x * (PIXELBREITE + 1);
  420.             pxy[1] = y_min + y * (PIXELBREITE + 1);
  421.             pxy[2] = pxy[0] + PIXELBREITE - 1;
  422.             pxy[3] = pxy[1] + PIXELBREITE - 1;
  423.             
  424.             mask = 0x8000 >> x;
  425.             vsf_interior(vdi_handle, (switch_bitmap[y] & mask
  426.                                                 ? FIS_SOLID
  427.                                                 : FIS_HOLLOW));
  428.             vr_recfl(vdi_handle, pxy);
  429.         }
  430.     
  431.     v_show_c(vdi_handle, 0);
  432. }
  433.  
  434.  
  435. /* ================================================================ */
  436.  
  437. void flip_pixel(int mx, int my)
  438. {
  439.     /* Vertauscht die Farbe des Pixels unter der    */
  440.     /* Maus. Der Drawing-Mode wird auf den akt.        */
  441.     /* Pixelwert gesetzt und bis zum Loslassen der    */
  442.     /* Maustaste beibehalten                        */
  443.     
  444.     int        pxy[4], x, y, raster_x, raster_y, mask, col;
  445.     
  446.     objc_offset(TREE[MAINFORM], RASTER, &x, &y);
  447.     x = (mx - x)/(PIXELBREITE + 1);
  448.     y = (my - y)/(PIXELBREITE + 1);
  449.     objc_offset(TREE[MAINFORM], RASTER, &raster_x, &raster_y);
  450.     
  451.     mask = 0x8000 >> x;
  452.     
  453.     switch (drawing_mode)
  454.     {
  455.         case TOGGLE    :    switch_bitmap[y] ^= mask;
  456.                         break;
  457.         case ON        :    switch_bitmap[y] |= mask;
  458.                         break;
  459.         case OFF    :    switch_bitmap[y] &= ~mask;
  460.                         break;
  461.     }
  462.     
  463.     col = switch_bitmap[y] & mask;
  464.     drawing_mode = (col ? ON : OFF);
  465.     
  466.     pxy[0] = raster_x + x * (PIXELBREITE + 1);
  467.     pxy[1] = raster_y + y * (PIXELBREITE + 1);
  468.     pxy[2] = pxy[0] + PIXELBREITE - 1;
  469.     pxy[3] = pxy[1] + PIXELBREITE - 1;
  470.     
  471.     vsf_interior(vdi_handle, (col ? FIS_SOLID : FIS_HOLLOW));
  472.     
  473.     v_hide_c(vdi_handle);
  474.     vr_recfl(vdi_handle, pxy);
  475.     copy_bitmap((char *) switch_bitmap, cur_switch);
  476.     v_show_c(vdi_handle, 0);
  477. }
  478.  
  479.  
  480. /* ================================================================ */
  481.  
  482. void copy_bitmap(char *src, int obj)
  483. {
  484.     /* Kopiert die Bitmap eines Schalters auf den    */
  485.     /* Schirm. Ein normales 'redraw' funktioniert    */
  486.     /* bei 'BITBLK'-Objekten leider nicht im        */
  487.     /* 'replace'-Modus...                            */
  488.     
  489.     int        pxy[8];
  490.     
  491.     bitmap_mfdb.fd_addr = src;
  492.     pxy[0] = pxy[1] = 0;
  493.     pxy[2] = RASTERBREITE - 1;
  494.     pxy[3] = RASTERHOEHE - 1;
  495.     
  496.     objc_offset(TREE[MAINFORM], obj, &pxy[4], &pxy[5]);
  497.     pxy[6] = pxy[4] + RASTERBREITE - 1;
  498.     pxy[7] = pxy[5] + RASTERHOEHE - 1;
  499.     
  500.     v_hide_c(vdi_handle);
  501.     vrt_cpyfm(vdi_handle, MD_REPLACE, pxy,
  502.                 &bitmap_mfdb, &screen_mfdb, color_index);
  503.     v_show_c(vdi_handle, 1);
  504. }
  505.  
  506.  
  507. /* ================================================================ */
  508.  
  509. void save_bitmap(void)
  510. {
  511.     /* Schreibt die Bitmap für eien Schalter und seinen Namen */
  512.     
  513.     int        exit;
  514.     FILE    *dest;
  515.     
  516.     strcat(path, "*.BBM");
  517.     if (fsel_input(path, f_name, &exit)
  518.         && (exit == 1) && f_name[0])
  519.     {
  520.         Biene;
  521.         *(strrchr(path, '\\') + 1) = 0;
  522.         strcat(path, f_name);
  523.         dest = fopen(path, "wb");
  524.         if (dest)
  525.         {
  526.             fwrite(on_bitmap, sizeof(int), RASTER_WORTE, dest);
  527.             fwrite(off_bitmap, sizeof(int), RASTER_WORTE, dest);
  528.             fwrite(schaltername, 1, 14, dest);
  529.             fclose(dest);
  530.         }
  531.         Pfeil;
  532.     }
  533.     *(strrchr(path, '\\') + 1) = 0;        /* Pfadnamen korrigieren */
  534. }
  535.  
  536.  
  537. /* ================================================================ */
  538.  
  539. void load_bitmap(void)
  540. {
  541.     /* Liest die Bitmap für einen Schalter und seinen Namen */
  542.     
  543.     int        exit;
  544.     FILE    *dest;
  545.     
  546.     strcat(path, "*.BBM");
  547.     if (fsel_input(path, f_name, &exit)
  548.         && (exit == 1) && f_name[0])
  549.     {
  550.         Biene;
  551.         *(strrchr(path, '\\') + 1) = 0;
  552.         strcat(path, f_name);
  553.         dest = fopen(path, "rb");
  554.         if (dest)
  555.         {
  556.             fread(on_bitmap, sizeof(int), RASTER_WORTE, dest);
  557.             fread(off_bitmap, sizeof(int), RASTER_WORTE, dest);
  558.             fread(schaltername, 1, 14, dest);
  559.             fclose(dest);
  560.             copy_bitmap((char *) off_bitmap, BUTNAUS);
  561.             copy_bitmap((char *) on_bitmap, BUTNEIN);
  562.             redraw(MAINFORM, SWTCHNME);
  563.         }
  564.         Pfeil;
  565.     }
  566.     *(strrchr(path, '\\') + 1) = 0;
  567. }
  568.  
  569.  
  570. /* ================================================================ */
  571.  
  572. void save_c_code(char *mode)
  573. {
  574.     /* Schreibt den C-Code für den aktuellen Schalter.    */
  575.     /* Wenn nicht angefügt wird, wird zusätzlich der    */
  576.     /* Datenstrukturheader erzeugt                        */
  577.     
  578.     int        exit, i;
  579.     FILE    *dest;
  580.     
  581.     if (schaltername[0] == 0)
  582.     {
  583.         form_alert(1, noname_alert);
  584.         return;
  585.     }
  586.     
  587.     strcat(path, "*.BTN");
  588.     if (strrchr(f_name, '.'))
  589.         strcpy(strrchr(f_name, '.') + 1, "*.BTN");
  590.     if (fsel_input(path, f_name, &exit)
  591.         && (exit == 1) && f_name[0])
  592.     {
  593.         Biene;
  594.         *(strrchr(path, '\\') + 1) = 0;
  595.         strcat(path, f_name);
  596.         dest = fopen(path, mode);
  597.         if (dest)
  598.         {
  599.             if (mode[0] == 'w') make_header(dest);
  600.             
  601.             fprintf(dest, "\nSWITCH %s = \n{", schaltername);
  602.             for (i = 0; i < RASTER_WORTE; i++)
  603.             {
  604.                 if (!(i % 8)) fprintf(dest, "\n\t");
  605.                 fprintf(dest, "%+#06x,", on_bitmap[i]);
  606.             }
  607.             fprintf(dest, "\n\t");
  608.             for (i = 0; i < RASTER_WORTE - 1; i++)
  609.             {
  610.                 if (!(i % 8)) fprintf(dest, "\n\t");
  611.                 fprintf(dest, "%+#06x,", off_bitmap[i]);
  612.             }
  613.             fprintf(dest, "%+#06x\n};\n", off_bitmap[RASTER_WORTE - 1]);
  614.             fclose(dest);
  615.         }
  616.         Pfeil;
  617.     }
  618.     *(strrchr(path, '\\') + 1) = 0;
  619. }
  620.  
  621.  
  622. /* ================================================================ */
  623.  
  624. void make_header(FILE *dest)
  625. {
  626.     /* Erzeugt einen Header mit der Datenstruktur    */
  627.     /* 'SWITCH'. Ist nur für den ersten Schalter    */
  628.     /* nötig, folgende können angefügt werden        */
  629.     
  630.     fprintf(dest,    "/**************************/\n"
  631.                     "/* Schalter-Datenstruktur */\n"
  632.                     "/**************************/\n");
  633.     fprintf(dest,    "\ntypedef struct\n{\n\tint on[%d];"
  634.                     "\n\tint off[%d];\n} SWITCH;\n\n",
  635.                     RASTER_WORTE, RASTER_WORTE);
  636.     fprintf(dest,    "/**************************/\n"
  637.                     "/*    Schalter-Bitmaps    */\n"
  638.                     "/**************************/\n");
  639. }